/**
 *	@file	pgmap_sub.c
 *	@brief	ポケギアマップ　サブ関数群
 *	@author	Miyuki Iwasawa
 *	@
 */

#include "common.h"
#include "system/procsys.h"
#include "system/arc_util.h"
#include "system/arc_tool.h"
#include "system/brightness.h"
#include "system/bmp_list.h"
#include "system/bmp_menu.h"
#include "system/pm_str.h"
#include "system/pm_rtc.h"
#include "system/msgdata.h"
#include "system/fontproc.h"
#include "system/snd_tool.h"
#include "system/clact_util.h"
#include "system/clact_tool.h"
#include "system/render_oam.h"
#include "system/wipe.h"
#include "system/buflen.h"
#include "system/palanm.h"
#include "gflib/touchpanel.h"
#include "itemtool/itemsym.h"
#include "field/field_matrix.h"
#include "field/field_place_name.h"
#include "application/app_tool.h"
#include "application/pokegear.h"
#include "msgdata/msg.naix"
#include "fielddata/maptable/zone_id.h"

#include "../pgear_sys.h"
#include "../pgear_frm.h"
#include "../pgear_act.h"
#include "pgmap_sys.h"
#include "pgmap_sub.h"
#include "pgmap_mk.h"

//実体はplace_name_core.c
extern void PNC_GetPlaceNameFromZoneID(	const int inZoneID,
										const u32 inHeapID,
										STRBUF *outName);

///////////////////////////////////////////////////////////////////////////////////
////field_revengeオーバーレイをロードした状態でないと使えません
/**
 *	@brief	再戦トレーナーチェック
 *
 *	@li  内部で呼び出すBS_TrainerIDCheck()がオーバレイfield_revengeに配置されてるので呼び出し注意
 *	@li 実体はfield/fld_pmtel.c FIELDSYS_WORKをincludeしたくないので、この関数のみ直接extern
 */
extern u16 FldPMTel_RevengeTrainerSearch(u8 tel_number,SAVEDATA* sv,PMTEL_BOOK_MAN* book,u8 time_zone);


static int sub_GetSkyTargetZone(PGMAP_SYS_WORK* wk,u16 x,u16 z);
static void sub_GetPlaceNameFromZoneID(u16 zone_id,int heapID,STRBUF* buf);
static BOOL sub_SkyJumpLocalAreaCheck(PGMAP_SYS_WORK* wk,u16 zone_id,u16 tx,u16 tz);

/**
 *	@brief	ポケギアマップ　アプリVBlank処理関数
 */
void PGMapSub_VBlank(PGEAR_SYS_WORK* sys_wk,void* app_wk)
{
	PGMAP_SYS_WORK* wk = (PGMAP_SYS_WORK*)app_wk;

	//スクロール状態更新
	if(wk->f_scrl_up){
		PGMapSub_MapBGScrollSet(wk,&wk->cScrl);
	}
}

/**
 *	@brief	スクロール座標から見えるエリアを特定
 */
void PGMapSub_SetViewAreaFromScroll(PGMAP_SYS_WORK* wk)
{
	u8 grid;
	if(wk->f_affine){
		grid = MAPF_GRID_SIZ2;
		wk->cScrl.b_u = (wk->cScrl.y+wk->cScrl.cy-8) / grid+1;
		wk->cScrl.b_l = (wk->cScrl.x+wk->cScrl.cx-8) / grid+1;
		wk->cScrl.b_d = wk->cScrl.b_u+(MAPF_GAFF1_H-1);
		wk->cScrl.b_r = wk->cScrl.b_l+(MAPF_GAFF1_W-1);
	}else{
		grid = MAPF_GRID_SIZ;
		wk->cScrl.b_u = (wk->cScrl.y*-1) / grid+1;
		wk->cScrl.b_l = wk->cScrl.x / grid+1;
		wk->cScrl.b_d = wk->cScrl.b_u+(MAPF_GAFF0_H-1);
		wk->cScrl.b_r = wk->cScrl.b_l+(MAPF_GAFF0_W-1);
	}
}
/**
 *	@brief	マーカー編集画面呼び出し時のパラメータ保存
 */
void PGMapSub_MapParamPush(PGMAP_SYS_WORK* wk)
{
	MI_CpuClear8(&wk->ret,sizeof(PGSYS_RET_PRM_MAP));
	wk->ret.word = PMS_WORD_NULL;

	wk->ret.valid = 1;

	//拡縮
	wk->ret.affine = wk->f_affine;

	//選択ターゲット位置
	wk->ret.tx = wk->cTarget.x;
	wk->ret.tz = wk->cTarget.z;
//	wk->ret.zone = wk->cTarget.zone;

	//選択カーソルの座標
	wk->ret.cur_x = wk->pActWMan->pAct[NACT_CURSOR].pos.x;
	wk->ret.cur_y = wk->pActWMan->pAct[NACT_CURSOR].pos.y;

	//スクロール座標
	wk->ret.sx = wk->cScrl.x;
	wk->ret.sy = wk->cScrl.y;
	wk->ret.cx = wk->cScrl.cx;
	wk->ret.cy = wk->cScrl.cy;
	wk->ret.l_u = wk->cScrl.b_u;
	wk->ret.l_d = wk->cScrl.b_d;
	wk->ret.l_l = wk->cScrl.b_l;
	wk->ret.l_r = wk->cScrl.b_r;
}

/*
 *	@brief	マーカー編集画面からのマップ画面への復帰時パラメータ書き戻し
 */
void PGMapSub_MapParamPop(PGMAP_SYS_WORK* wk)
{
	//選択ターゲット位置
	wk->cTarget.x = wk->ret.tx;
	wk->cTarget.z = wk->ret.tz;
//	wk->cTarget.zone = wk->ret.zone;

	//選択カーソルの座標
	wk->pActWMan->pAct[NACT_CURSOR].pos.x = wk->ret.cur_x;
	wk->pActWMan->pAct[NACT_CURSOR].pos.y = wk->ret.cur_y;

	//スクロール座標
	wk->cScrl.x = wk->ret.sx;
	wk->cScrl.y = wk->ret.sy;
	wk->cScrl.cx = wk->ret.cx;
	wk->cScrl.cy = wk->ret.cy;
	wk->cScrl.b_u = wk->ret.l_u;
	wk->cScrl.b_d = wk->ret.l_d;
	wk->cScrl.b_l = wk->ret.l_l;
	wk->cScrl.b_r = wk->ret.l_r;

	//保存パラメータ有効フラグを落としておく
	MI_CpuClear8(&wk->ret,sizeof(PGSYS_RET_PRM_MAP));
	wk->ret.word = PMS_WORD_NULL;

	wk->ret.valid = FALSE;
}

/**
 *	@brief	サブ画面内の指定座標が属するグリッドラインを返す
 *
 *	@param	f_aff	拡縮フラグ
 *	@param	x		サブ画面内でのドット位置x
 *	@param	y		サブ画面内でのドット位置y
 */
void PGMapSub_GetPosLine(PGMAP_SYS_WORK* wk,s16 x,s16 y,u16 *lineX,u16 *lineY)
{
	s16	px,py;

	//マップフレーム内での座標を取得
	px = x - wk->mapf_lsiz;
	py = y - wk->mapf_usiz;

	if(wk->f_affine){	//拡大
		*lineX = px / (MAPF_GRID_SIZ*2);
		*lineY = py / (MAPF_GRID_SIZ*2);
	}else{	//ノーマル
		*lineX = px / (MAPF_GRID_SIZ);
		*lineY = py / (MAPF_GRID_SIZ);
	}
}

/**
 *	@brief	現ターゲット位置にカーソル座標をあわせる
 */
void PGMapSub_SetCursor2TargetPos(PGMAP_SYS_WORK* wk)
{
	s16	cx,cy;
	u8	grid = (1+wk->f_affine);

	//オフセット取得
	cx = wk->cTarget.x-wk->cScrl.b_l;
	cy = wk->cTarget.z-wk->cScrl.b_u;

	cx = cx*(grid*MAPF_GRID_SIZ)+wk->mapf_lsiz+(MAPF_GRID_SIZ_H*grid);
	cy = cy*(grid*MAPF_GRID_SIZ)+wk->mapf_usiz+(MAPF_GRID_SIZ_H*grid);

	//カーソル座標に反映
	PGActWork_PosSetUpdate(&wk->pActWMan->pAct[NACT_CURSOR],cx,cy);
}


/**
 *	@brief	スクロールリミットを考慮して、移動先座標を取得
 */
void PGMapSub_GetAffMovePos(PGMAP_SYS_WORK* wk,u8 affine,u16 tx,u16 tz,s16 curX,s16 curY)
{
	u16	lineX,lineY;
	s16	dx,dy,lx,ly;
	s16	l_u,l_d,l_l,l_r;
	u8	typeX = 0,typeY = 0,grid;

	if(affine){	//拡大
		grid = MAPF_GRID_SIZ2;

		PGMapSub_GetPosLine(wk,curX,curY,&lineX,&lineY);

		//中心グリッドからの差分を取得
		dx = MAPF_GAFF1_CX-lineX;
		dy = MAPF_GAFF1_CY-lineY;

		//見えるエリアを特定
		l_u = tz - lineY - dy;
		l_d = tz + ((MAPF_GAFF1_H-1) - lineY) - dy;
		l_l = tx - lineX - dx;
		l_r = tx + ((MAPF_GAFF1_W-1) - lineX) - dx;

		IWASAWA_PRINT(" #ViewArea0= %d,%d : %d:%d\n",l_u,l_d,l_l,l_r);
	}else{	//ノーマル
		grid = MAPF_GRID_SIZ;

		//現スクロール座標から縮小時のラインを取得
		lineX = tx-(wk->cScrl.x/8+1);
		lineY = tz-(wk->cScrl.y/8+1);

		//中心グリッドからの差分を取得
		dx = MAPF_GAFF0_CX-lineX;
		dy = MAPF_GAFF0_CY-lineY;

		IWASAWA_PRINT(" #ViewLine= %d,%d : %d,%d\n",lineX,lineY,dx,dy);

		//見えるエリアを特定
		l_u = tz - lineY - dy;
		l_d = tz + ((MAPF_GAFF0_H-1) - lineY) - dy;
		l_l = tx - lineX - dx;
		l_r = tx + ((MAPF_GAFF0_W-1) - lineX) - dx;

		IWASAWA_PRINT(" #ViewArea0= %d,%d : %d:%d\n",l_u,l_d,l_l,l_r);
	}

	//スクロールリミットで補正
	if(l_u < wk->scrl.lim_bu){
		ly = (l_u-wk->scrl.lim_bu);
		dy += ly;
		l_u -= ly;
		l_d -= ly;
	}else if(l_d > wk->scrl.lim_bd){
		ly = (l_d-wk->scrl.lim_bd);
		dy += ly;
		l_d -= ly;
		l_u -= ly;
	}
	if(l_l < wk->scrl.lim_bl){
		lx = (l_l-wk->scrl.lim_bl);
		dx += lx;
		l_l -= lx;
		l_r -= lx;
	}else if(l_r > wk->scrl.lim_br){
		lx = (l_r-wk->scrl.lim_br);
		dx += lx;
		l_r -= lx;
		l_l -= lx;
	}
	//今見えてる範囲を覚えておく
	wk->cScrl.b_u = l_u;
	wk->cScrl.b_d = l_d;
	wk->cScrl.b_l = l_l;
	wk->cScrl.b_r = l_r;
	IWASAWA_PRINT(" #ViewArea1= %d,%d : %d:%d\n",l_u,l_d,l_l,l_r);

	//BGのスクロール差分を取得
	wk->cScrl.bg_d.x = -(dx*grid);
	wk->cScrl.bg_d.y = -(dy*grid);

	IWASAWA_PRINT(" #ScrollValue= %d,%d : %d:%d\n",dx,dy,wk->cScrl.bg_end.x,wk->cScrl.bg_end.y);
	IWASAWA_PRINT(" #getAffMovePos mode= %d , %d :%d\n",affine,dx,dy);

	//現在位置からの稼動距離を算出
	wk->cScrl.bg_end.x = wk->cScrl.x + wk->cScrl.bg_d.x;
	wk->cScrl.bg_end.y = wk->cScrl.y + wk->cScrl.bg_d.y;
	wk->cScrl.px = FX32_CONST(wk->cScrl.x);
	wk->cScrl.py = FX32_CONST(wk->cScrl.y);
	wk->cScrl.dx = FX_Div(FX32_CONST(wk->cScrl.bg_d.x),FX32_CONST(wk->key_move));
	wk->cScrl.dy = FX_Div(FX32_CONST(wk->cScrl.bg_d.y),FX32_CONST(wk->key_move));
}

/**
 *	@brief	拡縮センター座標を求める
 */
void PGMapSub_GetAffineCenter(PGMAP_SYS_WORK* wk,
		u16 tx,u16 tz,s16 cur_x,s16 cur_y,int* centerX,int* centerY)
{
	u8	typeX = 0,typeY = 0;

	//拡大→ノーマル
	if(wk->f_affine == 0){
		//拡縮中心座標を取得
		typeX = ((cur_x-wk->mapf_lsiz)/(MAPF_GRID_SIZ*2));
		typeY = ((cur_y-wk->mapf_usiz)/(MAPF_GRID_SIZ*2));
		if(typeX <= MAPF_GAFF1_CX){
			*centerX = tx*MAPF_GRID_SIZ+MAPF_GRID_SIZ;
		}else{
			*centerX = tx*MAPF_GRID_SIZ;
		}
		if(typeY > MAPF_GAFF1_CY){
			*centerY = tz*MAPF_GRID_SIZ+MAPF_GRID_SIZ;
		}else{
			*centerY = tz*MAPF_GRID_SIZ;
		}

	}else{	//ノーマル→拡大
		typeX = ((cur_x-wk->mapf_lsiz)/MAPF_GRID_SIZ)%2;
		typeY = ((cur_y-wk->mapf_usiz)/MAPF_GRID_SIZ)%2;

		//拡縮センター座標取得
		*centerX = tx*MAPF_GRID_SIZ+typeX*MAPF_GRID_SIZ;
		*centerY = tz*MAPF_GRID_SIZ+typeY*MAPF_GRID_SIZ;
	}
}

/*
 *	@brief	ブロック座標からメインマップスクロール座標の決定
 *	@
 */
void PGMapSub_MapBGIniScrollCalc(PGMAP_SYS_WORK* wk)
{
	s16	cx,cy;
	u16	affine,grid,grid_h;
	VecFx32	scale;
	PGEAR_ACT_WORK* pAct = wk->pActWMan->pAct;

	//拡縮モード設定
	if(wk->f_affine){
		affine = 2;
		grid = MAPF_GRID_SIZ2;
	}else{
		affine = 1;
		grid = MAPF_GRID_SIZ;
	}
	wk->cScrl.ax = FX32_CONST(affine);
	wk->cScrl.ay = FX32_CONST(affine);
	grid_h = grid/2;

	//スクロール初期位置設定
	if(wk->ret.valid){
		PGMapSub_MapParamPop(wk);
	}else{
		//初期カーソル座標セット
		PGMapSub_GetAffMovePos(wk,0,wk->cTarget.x,wk->cTarget.z,0,0);

		//初期カーソル/スクロール位置
		wk->cScrl.x = wk->cScrl.bg_end.x;
		wk->cScrl.y = wk->cScrl.bg_end.y;
		cx = ((wk->cTarget.x-wk->cScrl.b_l))*MAPF_GRID_SIZ+wk->mapf_lsiz+MAPF_GRID_SIZ_H;
		cy = ((wk->cTarget.z-wk->cScrl.b_u))*MAPF_GRID_SIZ+wk->mapf_usiz+MAPF_GRID_SIZ_H;
		IWASAWA_PRINT(" #Cursor= %d,%d\n",cx,cy);

		//拡大モードの場合、再計算
		if(wk->f_affine){
			PGMapSub_GetAffMovePos(wk,1,wk->cTarget.x,wk->cTarget.z,cx,cy);
			PGMapSub_GetAffineCenter(wk,
				wk->cTarget.x,wk->cTarget.z,cx,cy,&(wk->cScrl.cx),&(wk->cScrl.cy));

			wk->cScrl.x = wk->cScrl.bg_end.x;
			wk->cScrl.y = wk->cScrl.bg_end.y;
			cx = ((wk->cTarget.x-wk->cScrl.b_l))*grid+wk->mapf_lsiz+grid_h;
			cy = ((wk->cTarget.z-wk->cScrl.b_u))*grid+wk->mapf_usiz+grid_h;
		}
		PGActWork_PosSet(&pAct[NACT_CURSOR],cx,cy);
	}
	//初期カーソル・自機アイコン位置設定
	PGActWork_GridPosSet(&pAct[NACT_CURSOR],wk->cTarget.x,wk->cTarget.z);
	//カーソルの拡縮状態セット
	scale.x = scale.y = FX32_CONST(affine);
	scale.z = FX32_CONST(1);
	CLACT_SetScale(pAct[NACT_CURSOR].act,&scale);

	cx = ((wk->player.x-wk->cScrl.b_l))*grid+wk->mapf_lsiz+grid_h;
	cy = ((wk->player.z-wk->cScrl.b_u))*grid+wk->mapf_usiz+grid_h;
	PGActWork_PosSet(&pAct[NACT_HERO],cx,cy);
	PGActWork_GridPosSet(&pAct[NACT_HERO],wk->player.x,wk->player.z);
}

/*
 *	@brief	指定したスクロールパラメータをメインマップスクロール座標に反映
 *	@
 */
void PGMapSub_MapBGScrollSet(PGMAP_SYS_WORK* wk,_SCROLL* pScrl)
{
	int i;
	MtxFx22 mtx, lake_mtx;
    fx32 rScale_x,rScale_y;

	rScale_x = FX_Inv(pScrl->ax);
	rScale_y = FX_Inv(pScrl->ay);
    mtx._00 = rScale_x;
    mtx._01 = 0;
    mtx._10 = 0;
    mtx._11 = rScale_y;

	for(i = 0;i < 2;i++){
		GF_BGL_ScrollSet(wk->sys->bgl,GF_BGL_FRAME2_M+i,GF_BGL_SCROLL_X_SET,pScrl->x+wk->maps_wdef);
		GF_BGL_ScrollSet(wk->sys->bgl,GF_BGL_FRAME2_M+i,GF_BGL_SCROLL_Y_SET,pScrl->y+wk->maps_hdef);
		GF_BGL_AffineSet(wk->sys->bgl,GF_BGL_FRAME2_M+i,&mtx,pScrl->cx,pScrl->cy);
	}
	wk->f_scrl_up = 0;
}

/**
 *	@brief	指定したスクロールパラメータをマップの連動OBJに反映
 *
 *	@param	dx	相対x座標
 *	@param	dy	相対y座標
 */
void PGMapSub_MapObjScrollSet(PGMAP_SYS_WORK* wk,s16 dx,s16 dy)
{
	u16	i;

	PGEAR_ACT_WORK* pAct= wk->pActWMan->pAct;

	//自機アイコン
	PGActWork_PosMove(&pAct[NACT_HERO],dx,dy);
	if(wk->touch_st){
		PGActWork_PosMove(&pAct[NACT_CURSOR],dx,dy);
	}
	if(wk->map_mode){
		//空を飛ぶアイコン
		for(i = 0;i < SACT_NUM;i++){
			PGActWork_PosMove(&pAct[SACT_ICON+i],dx,dy);
		}
	}else{
		//移動ポケモンアイコン
		for(i = 0;i < MOVE_POKE_MAX;i++){
			PGActWork_PosMove(&pAct[NACT_POKE1+i],dx,dy);
		}
		//マーキングアイコン
		for(i = 0;i < MKACT_NUM;i++){
			PGActWork_PosMove(&pAct[MKACT_START+i],dx,dy);
		}
	}
}

/**
 *	@brief	メイン画面アプリフェード
 *
 *	＊フェード終了後に呼ばれても問題ないように組んでおく
 */
int PGMapSub_PalFadeWait(PGMAP_SYS_WORK* wk,u8 mode)
{
	u16 col;

	if(wk->palEvy > 16){
		return TRUE;
	}

	if(mode == 0){
		SoftFadePfd(wk->sys->palAnm,FADE_MAIN_BG,
				16*PGAPP_PALIDX_M,16*PGAPP_PALNUM_M,16-wk->palEvy,0x0000);
		SoftFadePfd(wk->sys->palAnm,FADE_MAIN_OBJ,
				16*PGAPPOAM_PALIDX_M,16*PGAPPOAM_PALNUM_M,16-wk->palEvy,0x0000);
	}else{
		SoftFadePfd(wk->sys->palAnm,FADE_MAIN_BG,
				16*PGAPP_PALIDX_M,16*PGAPP_PALNUM_M,wk->palEvy,0x0000);
		SoftFadePfd(wk->sys->palAnm,FADE_MAIN_OBJ,
				16*PGAPPOAM_PALIDX_M,16*PGAPPOAM_PALNUM_M,wk->palEvy,0x0000);
	}
	IWASAWA_PRINT("palEvy = %d\n",wk->palEvy);
	if(wk->palEvy >= 16){
		wk->palEvy += 2;
		return TRUE;
	}
	wk->palEvy += 2;
	return FALSE;
}

/*
 *	@brief	サブ画面スクロールセット
 *	@param	wk	マップワークへのポインタ
 *	@param	mode	0:展開,1:格納
 */
void PGMapSub_GuideScrollSet(PGMAP_SYS_WORK* wk,u8 mode)
{
	int i;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	//まずはウィンドウマスクセット
	G2S_SetWnd0Position(0,PGM_SUB_SCR_MASK,255,192);
	G2S_SetWnd1Position(255,PGM_SUB_SCR_MASK,0,192);
	G2S_SetWndOutsidePlane( GX_WND_PLANEMASK_BG0|GX_WND_PLANEMASK_OBJ,FALSE);
	G2S_SetWnd0InsidePlane(	GX_WND_PLANEMASK_BG0|GX_WND_PLANEMASK_BG1|
							GX_WND_PLANEMASK_BG2|GX_WND_PLANEMASK_BG3|
							GX_WND_PLANEMASK_OBJ, FALSE);
	G2S_SetWnd1InsidePlane(	GX_WND_PLANEMASK_BG0|GX_WND_PLANEMASK_BG1|
							GX_WND_PLANEMASK_BG2|GX_WND_PLANEMASK_BG3|
							GX_WND_PLANEMASK_OBJ, FALSE);
	GXS_SetVisibleWnd(GX_WNDMASK_W0|GX_WNDMASK_W1);

	if(mode == 0){
		//出すときは、スクロール値をセットしてから表示をOnにする
		for(i = 0;i < 3;i++){
			GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_S+i, GF_BGL_SCROLL_Y_SET,-PGM_SUB_SCR_SIZ);
			GF_BGL_VisibleSet(GF_BGL_FRAME1_S+i,VISIBLE_ON);
		}
		for(i = 0;i < 4;i++){
			PGActWork_PosSet(&pAct[NACT_MARK1+i],
				NACT_MARK_PX+NACT_MARK_SX*(i%2),
				NACT_MARK_PY+(i/2)*NACT_MARK_SY+PGMAP_SUBSURFACE_Y+PGM_SUB_SCR_SIZ);
		}
		PGActWork_PosSet(&pAct[NACT_REV],NACT_REVENGE_PX,
				NACT_REVENGE_PY+PGMAP_SUBSURFACE_Y+PGM_SUB_SCR_SIZ);

		PGActWorkMan_AllPosUpdate(wk->pActWMan);
	}else{
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_S, GF_BGL_SCROLL_Y_DEC, 0);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME2_S, GF_BGL_SCROLL_Y_DEC, 0);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME3_S, GF_BGL_SCROLL_Y_DEC, 0);
	}
	wk->sub_ct = 0;
	wk->sub_scr_end = 0;
}
/*
 *	@brief	サブ画面スクロール　終了待ち
 *	@param	wk	マップワークへのポインタ
 *	@param	mode	0:展開,1:格納
 */
int PGMapSub_GuideScrollWait(PGMAP_SYS_WORK* wk,u8 mode)
{
	int i;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	if(wk->sub_scr_end){
		return TRUE;	//終了状態で呼ばれても良いようにしておく
	}

	if(mode == 0){
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_S, GF_BGL_SCROLL_Y_INC, PGM_SUB_SCR_Y);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME2_S, GF_BGL_SCROLL_Y_INC, PGM_SUB_SCR_Y);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME3_S, GF_BGL_SCROLL_Y_INC, PGM_SUB_SCR_Y);
		for(i = NACT_MARK1;i <= NACT_REV;i++){
			PGActWork_PosMove(&pAct[i],0,-PGM_SUB_SCR_Y);
		}
	}else{
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_S, GF_BGL_SCROLL_Y_DEC, PGM_SUB_SCR_Y);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME2_S, GF_BGL_SCROLL_Y_DEC, PGM_SUB_SCR_Y);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME3_S, GF_BGL_SCROLL_Y_DEC, PGM_SUB_SCR_Y);
		for(i = NACT_MARK1;i <= NACT_REV;i++){
			PGActWork_PosMove(&pAct[i],0,PGM_SUB_SCR_Y);
		}
	}
	PGActWorkMan_AllPosUpdate(wk->pActWMan);

	if(++wk->sub_ct < PGM_SUB_SCR_CNT){
		return FALSE;
	}
	wk->sub_ct = 0;
	wk->sub_scr_end = 1;
	if(mode == 1){
		//隠すときは、表示をoffにしてから、スクロール値を元に戻しておく
		for(i = 0;i < 3;i++){
			GF_BGL_VisibleSet(GF_BGL_FRAME1_S+i,VISIBLE_OFF);
			GF_BGL_ScrClear(wk->sys->bgl,GF_BGL_FRAME1_S+i);
			GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_S+i, GF_BGL_SCROLL_Y_SET, 0);
			GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME1_S+i);
		}
	}
	//ウィンドウマスク解除
	GXS_SetVisibleWnd(GX_WNDMASK_NONE);
	G2S_SetWnd0Position(0,0,0,0);
	G2S_SetWnd1Position(0,0,0,0);
	G2S_SetWnd0InsidePlane(GX_WND_PLANEMASK_NONE,FALSE);
	G2S_SetWnd1InsidePlane(GX_WND_PLANEMASK_NONE,FALSE);
	G2S_SetWndOutsidePlane(GX_WND_PLANEMASK_NONE,FALSE);
	return TRUE;
}

/*
 *	@brief	メインマーク編集画面スクロールセット
 *	@param	wk	マップワークへのポインタ
 *	@param	mode	0:展開,1:格納
 */
void PGMapSub_MarkScrollSet(PGMAP_SYS_WORK* wk,u8 mode)
{
	int i;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	//まずはウィンドウマスクセット
	G2_SetWnd0Position(0,0,255,MARK_SCR_MASK);
	G2_SetWnd1Position(255,0,0,MARK_SCR_MASK);
	G2_SetWndOutsidePlane( GX_WND_PLANEMASK_BG3|GX_WND_PLANEMASK_OBJ,FALSE);
	G2_SetWnd0InsidePlane(	GX_WND_PLANEMASK_BG0|GX_WND_PLANEMASK_BG1|
							GX_WND_PLANEMASK_BG2|GX_WND_PLANEMASK_BG3|
							GX_WND_PLANEMASK_OBJ, FALSE);
	G2_SetWnd1InsidePlane(	GX_WND_PLANEMASK_BG0|GX_WND_PLANEMASK_BG1|
							GX_WND_PLANEMASK_BG2|GX_WND_PLANEMASK_BG3|
							GX_WND_PLANEMASK_OBJ, FALSE);
	GX_SetVisibleWnd(GX_WNDMASK_W0|GX_WNDMASK_W1);

	if(mode == 0){
		//出すときは、スクロール値をセットしてから表示をOnにする
		for(i = 0;i < 2;i++){
			GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_M+i, GF_BGL_SCROLL_Y_SET,MARK_SCR_SIZ);
		}
		for(i = EACT_MARK1;i <= EACT_PLATE4;i++){
			PGActWork_PosMove(&pAct[i],0,-MARK_SCR_SIZ);
		}
		PGActWorkMan_AllPosUpdate(wk->pActWMan);
		//プレートにあわせてFontOamも動く
		for(i = 0;i < 4;i++){
			FONTOAM_SetMat(wk->pFontOam[i].foam,FOAM_PLATE_OFSX, FOAM_PLATE_OFSY);
		}
	}else{
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_M, GF_BGL_SCROLL_Y_DEC, 0);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME2_M, GF_BGL_SCROLL_Y_DEC, 0);

		//矢印を隠す
		CLACT_SetDrawFlag(wk->pActWMan->pAct[EACT_ARROW].act,FALSE);
	}
	wk->sub_ct = 0;
	wk->sub_scr_end = 0;
}
/*
 *	@brief	マーク画面スクロール　終了待ち
 *	@param	wk	マップワークへのポインタ
 *	@param	mode	0:展開,1:格納
 */
int PGMapSub_MarkScrollWait(PGMAP_SYS_WORK* wk,u8 mode)
{
	int i;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	if(wk->sub_scr_end){
		return TRUE;	//終了状態で呼ばれても良いようにしておく
	}

	if(mode == 0){
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_M, GF_BGL_SCROLL_Y_DEC, MARK_SCR_Y);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME2_M, GF_BGL_SCROLL_Y_DEC, MARK_SCR_Y);
		for(i = EACT_MARK1;i <= EACT_PLATE4;i++){
			PGActWork_PosMove(&pAct[i],0,MARK_SCR_Y);
		}
	}else{
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_M, GF_BGL_SCROLL_Y_INC, MARK_SCR_Y);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME2_M, GF_BGL_SCROLL_Y_INC, MARK_SCR_Y);
		for(i = EACT_MARK1;i <= EACT_PLATE4;i++){
			PGActWork_PosMove(&pAct[i],0,-MARK_SCR_Y);
		}
	}
	PGActWorkMan_AllPosUpdate(wk->pActWMan);

	//プレートにあわせてFontOamも動く
	for(i = 0;i < 4;i++){
		FONTOAM_SetMat(wk->pFontOam[i].foam,FOAM_PLATE_OFSX, FOAM_PLATE_OFSY);
	}

	if(++wk->sub_ct < MARK_SCR_CNT){
		return FALSE;
	}
	wk->sub_ct = 0;
	wk->sub_scr_end = 1;

	if(mode == 1){
		//隠すときは、表示をoffにしてから、スクロール値を元に戻しておく
		for(i = 0;i < 2;i++){
//			GF_BGL_VisibleSet(GF_BGL_FRAME1_M+i,VISIBLE_OFF);
			GF_BGL_ScrClear(wk->sys->bgl,GF_BGL_FRAME1_M+i);
//			GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_M+i, GF_BGL_SCROLL_Y_SET, 0);
			GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME1_M+i);
		}
	}

	//ウィンドウマスク解除
	GX_SetVisibleWnd(GX_WNDMASK_NONE);
	G2_SetWnd0Position(0,0,0,0);
	G2_SetWnd1Position(0,0,0,0);
	G2_SetWnd0InsidePlane(GX_WND_PLANEMASK_NONE,FALSE);
	G2_SetWnd1InsidePlane(GX_WND_PLANEMASK_NONE,FALSE);
	G2_SetWndOutsidePlane(GX_WND_PLANEMASK_NONE,FALSE);

	if(mode == 0){
		//矢印を表示開始
		CLACT_SetDrawFlag(wk->pActWMan->pAct[EACT_ARROW].act, TRUE);

		//選択カーソルの表示状態制御
		if(wk->sys->key_mode != APP_KTST_TOUCH){
			CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,PGKM_APP_PARAM1,TRUE);
		}
	}
	return TRUE;
}

/**
 *	@brief	マーキングアイコン　ポジション＆Viewセット
 *
 *	@param	mode	0:posにポジションセット,1:ex,eyにポジションセット
 */
void PGMapSub_MarkPosViewSet(PGMAP_SYS_WORK* wk,u8 mode)
{
	u16	i,idx;
	s16	x,y;
	u8	grid,grid_h,scale;
	MAP_ZONE_PARAM* pp;

	scale = 1+wk->f_affine;
	grid = MAPF_GRID_SIZ*scale;
	grid_h = grid/2;

	//マークセット
	for(i = 0;i < MKACT_NUM;i++){
		pp = (MAP_ZONE_PARAM*)&(wk->pMZoneTbl[i]);
		x = (pp->x-wk->cScrl.b_l)*grid+wk->mapf_lsiz+grid_h+(pp->dx*scale);
		y = (pp->z-wk->cScrl.b_u)*grid+wk->mapf_usiz+grid_h+(pp->dy*scale);

		idx = i + MKACT_START;
		switch(mode){
		case 0:
			wk->pActWMan->pAct[idx].pos.x = x;
			wk->pActWMan->pAct[idx].pos.y = y;

			//有効データがあるかどうかで分岐
			if(PGMapMk_SearchListFromZone(wk,pp->zone_id)){
				CLACT_SetDrawFlag(wk->pActWMan->pAct[idx].act, TRUE);
				PGActWork_ViewSet(&wk->pActWMan->pAct[idx],TRUE);
			}else{
				CLACT_SetDrawFlag(wk->pActWMan->pAct[idx].act, FALSE);
				PGActWork_ViewSet(&wk->pActWMan->pAct[idx],FALSE);
			}
			break;
		case 1:
			wk->pActWMan->pAct[idx].ex = x;
			wk->pActWMan->pAct[idx].ey = y;
			break;
		case 2:
			CLACT_SetDrawFlag(wk->pActWMan->pAct[idx].act, FALSE);
			PGActWork_ViewSet(&wk->pActWMan->pAct[idx],FALSE);
			break;
		}
	}
	//移動ポケモンマークセット
	for(i = 0;i < MOVE_POKE_MAX;i++){
		idx = i + NACT_POKE1;

		//有効データチェック
		if(wk->mv_poke_zone[i] == 0){
			PGActWork_ViewSet(&wk->pActWMan->pAct[idx],FALSE);
			CLACT_SetDrawFlag(wk->pActWMan->pAct[idx].act, FALSE);
			continue;
		}
		pp = PGMapSub_GetZoneParamFromID(wk,wk->mv_poke_zone[i]);
		x = (pp->x-wk->cScrl.b_l)*grid+wk->mapf_lsiz+grid_h+(pp->dx*scale);
		y = (pp->z-wk->cScrl.b_u)*grid+wk->mapf_usiz+grid_h+(pp->dy*scale);

		switch(mode){
		case 0:
			wk->pActWMan->pAct[idx].pos.x = x;
			wk->pActWMan->pAct[idx].pos.y = y;

			PGActWork_ViewSet(&wk->pActWMan->pAct[idx],TRUE);
			CLACT_SetDrawFlag(wk->pActWMan->pAct[idx].act, TRUE);
			break;
		case 1:
			wk->pActWMan->pAct[idx].ex = x;
			wk->pActWMan->pAct[idx].ey = y;
			break;
		case 2:
			PGActWork_ViewSet(&wk->pActWMan->pAct[idx],FALSE);
			CLACT_SetDrawFlag(wk->pActWMan->pAct[idx].act, FALSE);
			break;
		}
	}
}

/**
 *	@brief	空を飛ぶアイコンセット
 */
void PGMapSub_SkyPosViewSet(PGMAP_SYS_WORK* wk,u8 mode)
{
	u16	i,idx;
	s16	x,y,ox,oy;
	u8	grid,grid_h,local;
	TMAP_TOWN_PARAM* tp;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	grid = MAPF_GRID_SIZ;
	grid_h = grid/2;

	for(i = 0;i < SACT_NUM;i++){
		tp = (TMAP_TOWN_PARAM*)&(TMapTownParam[i]);
		ox = tp->asx*4;
		oy = tp->asy*4;
		x = (tp->px-wk->cScrl.b_l)*grid+wk->mapf_lsiz+ox;
		y = ((tp->pz+PGMAP_MATOFS_Z)-wk->cScrl.b_u)*grid+wk->mapf_usiz+oy;

		idx = i + SACT_ICON;
		switch(mode){
		case 0:
			wk->pActWMan->pAct[idx].pos.x = x;
			wk->pActWMan->pAct[idx].pos.y = y;

			//有効データがあるかどうかで分岐
			if(SysFlag_ArriveGet(wk->sys->ev_save,tp->arrive)){
				CLACT_SetDrawFlag(wk->pActWMan->pAct[idx].act, TRUE);
			}else{
				CLACT_SetDrawFlag(wk->pActWMan->pAct[idx].act, FALSE);
			}
			if(	sub_SkyJumpLocalAreaCheck(wk,tp->jump_zone,tp->px,tp->pz)){
				CLACT_AnmChg(wk->pActWMan->pAct[idx].act,ANM_H_SKY02);
			}
			break;
		case 1:
			wk->pActWMan->pAct[idx].ex = x;
			wk->pActWMan->pAct[idx].ey = y;
			break;
		case 2:
			CLACT_SetDrawFlag(wk->pActWMan->pAct[idx].act, FALSE);
			break;
		}
	}
}

/**
 *	@brief	マーク画面In/Out時　OBJ描画コントロール
 *	@param	mode	0:in,1:out
 */
void PGMapSub_MapObjSetIOMark(PGMAP_SYS_WORK* wk,u8 mode)
{
	int i;
	PGEAR_ACT_WORK* pAct = wk->pActWMan->pAct;

	if(mode == 0){	//in
		//自機とマップ選択カーソルを隠す
		CLACT_SetDrawFlag(pAct[NACT_CURSOR].act,FALSE);
		CLACT_SetDrawFlag(pAct[NACT_HERO].act,FALSE);

		//ポケモンアイコンを隠す
		for(i = NACT_POKE1;i <= NACT_POKE4;i++){
			CLACT_SetDrawFlag(pAct[i].act,FALSE);
		}
	}else{	//out
		//自機とマップ選択カーソルを表示
		CLACT_SetDrawFlag(pAct[NACT_CURSOR].act,TRUE);
		CLACT_SetDrawFlag(pAct[NACT_HERO].act,TRUE);
	}
}

/**
 *	@brief	条件によって無視するゾーンのチェック
 */
static BOOL sub_IsEgnoreZone(PGMAP_SYS_WORK* wk,int zone_id)
{
	switch(zone_id){
	case ZONE_ID_R47:
	case ZONE_ID_R48:
	case ZONE_ID_D47:
		if(!wk->arrive_safari){	//サファリは到着してないと無視
			return TRUE;
		}
		break;
	case PGMAP_SHINTO_ZONE:
		if(!wk->arrive_shinto){
			return TRUE;
		}
		break;
	case PGMAP_SHIP_ZONE:
		if(!wk->arrive_ship){
			return TRUE;
		}
		break;
	}
	return FALSE;
}

/**
 *	@brief	マーキング可能なゾーンかどうかのチェック
 */
BOOL PGMapSub_IsMarkingEnable(PGMAP_SYS_WORK* wk,TARGET_ZONE* ptz)
{
	if(ptz->z_prm == NULL){
		return FALSE;
	}
	//シントとアクア号はマーキングできない
	if(	ptz->z_prm->zone_id == PGMAP_SHINTO_ZONE ||
		ptz->z_prm->zone_id == PGMAP_SHIP_ZONE){
		return FALSE;
	}
	return TRUE;
}

/*
 *	@brief	現在のターゲットゾーンを取得
 */
MAP_ZONE_PARAM* PGMapSub_GetZoneParam(PGMAP_SYS_WORK* wk,u8 tx,u8 tz)
{
	u16 i;
	MAP_ZONE_PARAM* pp;

	for(i = 0;i < wk->zTblMax;i++){
		pp = (MAP_ZONE_PARAM*)&wk->pMZoneTbl[i];

		if(	tx < pp->x ||
			tz < pp->z ||
			tx >= (pp->x + pp->sx) ||
			tz >= (pp->z + pp->sz)){
			continue;
		}
		//HIT
		OS_Printf("ZoneHit %d (%d,%d)\n",i,tx,tz);
		if(sub_IsEgnoreZone(wk,pp->zone_id)){
			return NULL;
		}
		return pp;
	}
	return NULL;
}

/*
 *	@brief	ゾーンIDからゾーンパラメータを取得
 */
MAP_ZONE_PARAM* PGMapSub_GetZoneParamFromID(PGMAP_SYS_WORK* wk,u16 zone)
{
	u16 i;
	MAP_ZONE_PARAM* pp;

	for(i = 0;i < wk->zTblMax;i++){
		pp = (MAP_ZONE_PARAM*)&wk->pMZoneTbl[i];

		if(	pp->zone_id != zone){
			continue;
		}
		//HIT

		if(sub_IsEgnoreZone(wk,pp->zone_id)){
			return NULL;
		}
		return pp;
	}
	return NULL;
}

/**
 *	@brief	座標からタウンパラメータを取得
 */
TMAP_TOWN_PARAM* PGMapSub_GetTownParam(PGMAP_SYS_WORK* wk,u8 tx,u8 tz)
{
	u8 i;
	TMAP_TOWN_PARAM* tp;

	for(i = 0;i < PGMAP_TOWN_MAX;i++){
		tp = (TMAP_TOWN_PARAM*)&(TMapTownParam[i]);
		if(	tx < tp->px ||
			tz < tp->pz ||
			tx >= (tp->px + tp->asx) ||
			tz >= (tp->pz + tp->asy)){
			continue;
		}
		//HIT
		if(sub_IsEgnoreZone(wk,tp->zoneid)){
			return NULL;
		}

		return tp;
	}
	return NULL;
}


/*
 *	@brief	現在のターゲットゾーンデータを取得
 */
void PGMapSub_GetNowZone(PGMAP_SYS_WORK* wk,TARGET_ZONE* pp,u8 tx,u8 tz)
{
	pp->z_prm = PGMapSub_GetZoneParam(wk,tx,tz);

	if(wk->f_open == 0){
		if((!(tx == 25 && tz == 10)) && tx >= 22){	//シロガネ山はヒットさせる
			pp->z_prm = NULL;
		}
	}
	if(pp->z_prm == NULL){
		pp->mk_prm = NULL;
	}else{
		pp->mk_prm =PGMapMk_SearchListFromZone(wk,wk->cZone.z_prm->zone_id);
	}
	pp->tx = tx;
	pp->tz = tz;
}

/**
 *	@brief	プレイヤーがいる地方のチェック
 */
BOOL PGMapSub_PlayerLocalCheck(PGMAP_SYS_WORK* wk,u16 tx,u16 tz)
{
	int local = PGFrame_GetLocalAreaPos(tx,tz);

	IWASAWA_PRINT(" LocalCheck my_local = %d, local = %d\n",wk->my_local,local);
	if(	wk->my_local == PGLOCAL_SEKIEI || local == wk->my_local){
		return TRUE;
	}
	return FALSE;
}

/*
 *	@brief	空を飛ぶ　ローカルエリアチェック
 */
static BOOL sub_SkyJumpLocalAreaCheck(PGMAP_SYS_WORK* wk,u16 zone_id,u16 tx,u16 tz)
{
	if(	(zone_id == ZONE_ID_T10)||
		(zone_id == ZONE_ID_R26)){	//セキエイ高原と26番道路は無条件
		return TRUE;
	}
	return PGMapSub_PlayerLocalCheck(wk,tx,tz);
}

/*
 *	@brief	指定ゾーンが空を飛ぶのターゲットかどうか？
 */
static int sub_GetSkyTargetZone(PGMAP_SYS_WORK* wk,u16 x,u16 z)
{
	int i;
	TMAP_TOWN_PARAM* tp;

	OS_Printf("GetSkyTarget x = %d,z = %d\n",x,z);
	for(i = 0;i < PGMAP_TOWN_MAX;i++){
		tp = (TMAP_TOWN_PARAM*)&(TMapTownParam[i]);

		//座標チェック
		if(	x < tp->px || x >= (tp->px+tp->asx) ||
			z < tp->pz || z >= (tp->pz+tp->asy)){
			continue;
		}
		if(!SysFlag_ArriveGet(wk->sys->ev_save,tp->arrive)){
			continue;
		}
		OS_Printf("GetSkyTarget Hit %d!\n",i);
		return i;
	}
	return -1;
}

/**
 *	@brief	その場所に飛んでいいかどうかチェック
 *
 *	@retval	飛ぶゾーンを返す(0なら違う)
 */
int PGMapSub_JumpTargetCheck(PGMAP_SYS_WORK* wk,u16 tx,u16 tz)
{
	int ret;
#ifdef PM_DEBUG
	if(wk->debug_f){
		return GetFieldMatrixZoneID((FMZ_CONST_PTR)wk->pZone,tx,tz);
	}
#endif
	ret = sub_GetSkyTargetZone(wk,tx,tz);
	if(ret < 0 || !sub_SkyJumpLocalAreaCheck(wk,TMapTownParam[ret].jump_zone,tx,tz)){
		return 0;
	}
//	return TMapTownParam[ret].zoneid;
	return TMapTownParam[ret].jump_zone;
}

/*
 *	@brief	現在のターゲットゾーンデータを取得
 */
int PGMapSub_GetNowZoneSky(PGMAP_SYS_WORK* wk,TARGET_ZONE* pp,u8 tx,u8 tz)
{
	int zone;
	int ret,old;

	//現在選択されているゾーンを取得
	ret = sub_GetSkyTargetZone(wk,tx,tz-PGMAP_MATOFS_Z);
	if(ret < 0){
		PGMapSub_GetNowZone(wk,pp,tx,tz);
		if(wk->jump_target >= 0){
			CLACT_AnmChg(wk->pActWMan->pAct[SACT_ICON+wk->jump_target].act,ANM_H_SKY02);
			wk->jump_target = -1;
		}
		return -1;
	}else{
		zone = TMapTownParam[ret].zoneid;
		pp->tx = tx;
		pp->tz = tz;
		pp->z_prm = PGMapSub_GetZoneParamFromID(wk,zone);
	}
#if 0
	ret = sub_GetSkyTargetZone(wk,tx,tz-PGMAP_MATOFS_Z);

	if(ret < 0){
		pp->z_prm = NULL;
		pp->mk_prm = NULL;
		if(wk->jump_target >= 0){
			CLACT_AnmChg(wk->pActWMan->pAct[SACT_ICON+wk->jump_target].act,ANM_H_SKY02);
			wk->jump_target = -1;
		}
		return -1;
	}
#endif
	//選択ターゲットのアニメパターンを変更
	if(wk->jump_target != ret){
		if(wk->jump_target >= 0){
			CLACT_AnmChg(wk->pActWMan->pAct[SACT_ICON+wk->jump_target].act,ANM_H_SKY02);
			wk->jump_target = -1;
		}
		if(	sub_SkyJumpLocalAreaCheck(wk,zone,tx,tz-PGMAP_MATOFS_Z)){
			CLACT_AnmChg(wk->pActWMan->pAct[SACT_ICON+ret].act,ANM_H_SKY03);
			wk->jump_target = ret;
			IWASAWA_PRINT(" JumpTarget CurrentOn = %d\n",ret);
		}
	}
	pp->mk_prm =PGMapMk_SearchListFromZone(wk,zone);
	return zone;
}

/**
 *	@brief	そのゾーンに再戦可能なトレーナーがいるかどうか？
 */
static BOOL pgmapsub_TrainerPromiseCheck(PGMAP_SYS_WORK* wk,int zone_id)
{
	int i,time_zone;
	PMTEL_BOOK* pb;

	time_zone = GF_RTC_GetGSTimeZone();

	for(i = 0;i < wk->tel_nummax;i++){
		pb = &wk->tel_book->data[wk->tel_number[i]];
		//ゾーンチェック
		if(pb->map_id != zone_id){
			continue;
		}
		if(pb->play_list != TEL_PLAYL_REVENGE){
			continue;
		}
		if(FldPMTel_RevengeTrainerSearch(wk->tel_number[i],
				wk->sys->save, wk->tel_book,time_zone) != 0){
			return TRUE;
		}
		if(PMTelSv_ItemEvDataGet(wk->tel_sv,wk->tel_number[i]) != ITEM_DUMMY_DATA){
			return TRUE;
		}
	}
	return FALSE;
}

/**
 *	@brief	ガイド表示コア
 */
static void pgmapsub_DrawGuide(PGMAP_SYS_WORK* wk,BOOL bgmode_f,BOOL is_kanto)
{
	u32	siz,i,idx;
	u8	x;
	GF_PRINTCOLOR col;
	STRBUF* buf;
	TARGET_ZONE* pp;
	MAP_ZONE_PARAM *zp;
	MARKER_LIST* mp;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	//データポインタ取得
	pp = &wk->cZone;
	zp = pp->z_prm;
	mp = pp->mk_prm;

	//いったんクリア
	STRBUF_Clear(wk->msgDat.place);
	for(i = WIN_G01;i < WIN_MK01;i++){
		GF_BGL_BmpWinDataFill(&(wk->win[i]),0);
	}
	col = GF_PRINTCOLOR_MAKE(1,2,0);

	//ジョウト/カントー書き換え
	GF_STR_PrintColor( &(wk->win[WIN_G01]),FONT_SYSTEM,
		wk->msgDat.area[is_kanto],
		2,4,MSG_NO_PUT,FCOL_WHITE,NULL );

	//Yボタン表示切替
	if(wk->map_mode == MAP_MODE_PG){
		if(!PGMapSub_IsMarkingEnable(wk,pp)){
			PGMapSub_MapPanelStChange(wk,0,2);
		}else{
			PGMapSub_MapPanelStChange(wk,0,0);
		}
	}
	//bg書換え
	if(zp != NULL){
		//マップ名取得
		sub_GetPlaceNameFromZoneID(zp->zone_id,wk->heapID,
									wk->msgDat.place);

		if(wk->map_mode == MAP_MODE_BG){
			siz = 1;
		}else{
			siz = 0;
		}
		GF_STR_PrintColor(	&(wk->win[WIN_G02]),FONT_SYSTEM,
							wk->msgDat.place,
							0,siz,MSG_NO_PUT,FCOL_WHITE,NULL );

		if(bgmode_f){	//BGモードのとき
			for(i = WIN_G01;i <= WIN_G02;i++){
				GF_BGL_BmpWinOn(&(wk->win[i]));
			}

			GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME2_S,
				23,11,8,7,wk->pSGuide->rawData,0,0,
				wk->pSGuide->screenWidth/8,wk->pSGuide->screenHeight/8);

			GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME1_S);
			GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME2_S);
			return;
		}
		//BG書換え
		if(	zp->town_idx != 0){
			x = 8;
			idx = zp->town_idx-1;
		}else{
			x = 0;
			idx = 0;
		}
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME2_S,
			23,11,8,7,wk->pSGuide->rawData,x,0,
			wk->pSGuide->screenWidth/8,wk->pSGuide->screenHeight/8);
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_S,
			24,11,7,7,wk->pSGMap->rawData,(idx%4)*7,(idx/4)*7,
			wk->pSGMap->screenWidth/8,wk->pSGMap->screenHeight/8);

		//ガイドメッセージ表示
		STRBUF_Clear(wk->msgDat.tmp);
		MSGMAN_GetString( wk->msgDat.gMan,zp->msg_id,wk->msgDat.tmp);
		GF_STR_PrintColor(	&(wk->win[WIN_G03]),FONT_SYSTEM,wk->msgDat.tmp,
							0,0,MSG_NO_PUT,FCOL_WHITE,NULL );

		//再戦トレーナーアイコン表示
		CLACT_SetDrawFlag(pAct[NACT_REV].act,pgmapsub_TrainerPromiseCheck(wk,zp->zone_id));
	}else{
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME2_S,
			23,11,8,7,wk->pSGuide->rawData,0,0,
			wk->pSGuide->screenWidth/8,wk->pSGuide->screenHeight/8);
		CLACT_SetDrawFlag(pAct[NACT_REV].act, FALSE);
	}

	//マーキング表示
	if(mp != NULL){
		GF_BGL_BmpWinDataFill(&(wk->win[WIN_MK01]),0);
		GF_BGL_BmpWinDataFill(&(wk->win[WIN_MK02]),0);
		for(i = 0;i < 4;i++){
			idx = NACT_MARK1+i;
			//アイコン表示制御
			if(mp->mark.icon[i] != MARKER_ICON_NULL){
				CLACT_SetDrawFlag(pAct[idx].act,TRUE);
				CLACT_AnmFrameSet(pAct[idx].act,mp->mark.icon[i]);
			}else{
				CLACT_SetDrawFlag(pAct[idx].act,FALSE);
			}
			//簡易会話表示制御
			if(mp->mark.word[i] != PMS_WORD_NULL){
				WORDSET_RegisterPMSWord(wk->msgDat.wset, 0, mp->mark.word[i] );
				WORDSET_ExpandStr(wk->msgDat.wset,wk->msgDat.tmp,wk->msgDat.pms_word);
				GF_STR_PrintColor( &(wk->win[WIN_MK01+(i%2)]),FONT_SYSTEM,
							wk->msgDat.tmp,
							4,(i/2)*21+2,MSG_NO_PUT,FCOL_BLACK,NULL );
			}
		}
	}else{
		//マーキングを隠す
		for(i = 0;i < 4;i++){
			CLACT_SetDrawFlag(pAct[NACT_MARK1+i].act,FALSE);
			GF_BGL_BmpWinDataFill(&(wk->win[WIN_MK01+i]),0);
		}
	}


	//ウィンドウ表示
	for(i = WIN_G01;i <= WIN_MK02;i++){
		GF_BGL_BmpWinOn(&(wk->win[i]));
	}
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME1_S);
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME2_S);
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME3_S);

}

/**
 *	@brief	ターゲットゾーンの上画面ガイドを描画
 **/
void PGMapSub_DrawGuide(PGMAP_SYS_WORK* wk,BOOL bgmode_f)
{
	pgmapsub_DrawGuide(wk,bgmode_f,
		(PGFrame_GetLocalAreaPos(wk->cTarget.x,wk->cTarget.z-PGMAP_MATOFS_Z)/2)^1);
}

/**
 *	@brief	ターゲットゾーンの上画面ガイドを描画(空を飛ぶ)
 **/
void PGMapSub_DrawGuideSky(PGMAP_SYS_WORK* wk)
{
	pgmapsub_DrawGuide(wk,FALSE,(wk->cZone.tx/MAP_AREA_KANTO));
}

/**
 *	@brief	下画面ガイドのFontOam簡易会話を書き換える
 */
static void pgmapsub_DrawFOamPWord(PGMAP_SYS_WORK* wk,u8 idx,u16 word)
{
	if(word == PMS_WORD_NULL){
		FONTOAM_SetDrawFlag(wk->pFontOam[idx].foam,FALSE);
		return;
	}
	WORDSET_RegisterPMSWord(wk->msgDat.wset, 0, word);
	WORDSET_ExpandStr(wk->msgDat.wset,wk->msgDat.tmp,wk->msgDat.pms_word);

	GF_BGL_BmpWinObjDataFill(&(wk->win[WIN_ME02]),FBMP_COL_NULL);

	GF_STR_PrintColor( &(wk->win[WIN_ME02]),FONT_SYSTEM,
						wk->msgDat.tmp,
						0,0,MSG_NO_PUT,FCOL_BLACK,NULL );
	//フォントOAMに書き換えたBMPをセット
	FONTOAM_OAMDATA_ResetBmp(
		wk->pFontOam[idx].foam, wk->pFOamData,&(wk->win[WIN_ME02]),wk->heapID);

	FONTOAM_SetDrawFlag(wk->pFontOam[idx].foam,TRUE);
}

/**
 *	@brief	ターゲットゾーンの下画面ガイドを描画
 *
 *	@param	flag	TRUEなら地名も書き換える
 **/
void PGMapSub_DrawEditGuide(PGMAP_SYS_WORK* wk,u8 flag)
{
	u32	siz,i,idx;
	u8	x;
	GF_PRINTCOLOR col;
	STRBUF* buf;
	TARGET_ZONE* pp;
	MAP_ZONE_PARAM *zp;
	MARKER_LIST* mp;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	//データポインタ取得
	pp = &wk->cZone;
	zp = pp->z_prm;
	mp = pp->mk_prm;

	col = GF_PRINTCOLOR_MAKE(1,2,0);

	if(flag){
		STRBUF_Clear(wk->msgDat.place);
		for(i = WIN_ME01;i <= WIN_ME01;i++){
			GF_BGL_BmpWinDataFill(&(wk->win[i]),0);
		}

		//マップ名取得
		sub_GetPlaceNameFromZoneID(zp->zone_id,wk->heapID,wk->msgDat.place);

		GF_STR_PrintColor(	&(wk->win[WIN_ME01]),FONT_SYSTEM,
							wk->msgDat.place,
							0,5,MSG_ALLPUT,FCOL_WHITE,0);

		GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME1_M);
	}

	//マーキング表示
	if(mp == NULL){
		//マーキングを隠す
		for(i = 0;i < 4;i++){
			CLACT_SetDrawFlag(pAct[EACT_MARK1+i].act,FALSE);
			pgmapsub_DrawFOamPWord(wk,i,PMS_WORD_NULL);
		}
		return;
	}
	//マーキング表示
	for(i = 0;i < 4;i++){
		//アイコン表示
		if(mp->mark.icon[i] == MARKER_ICON_NULL){
			CLACT_SetDrawFlag(pAct[EACT_MARK1+i].act,FALSE);
		}else{
			CLACT_AnmFrameSet(pAct[EACT_MARK1+i].act,mp->mark.icon[i]);
			CLACT_SetDrawFlag(pAct[EACT_MARK1+i].act,TRUE);
		}
		//簡易会話OAM表示
		pgmapsub_DrawFOamPWord(wk,i,mp->mark.word[i]);
	}
}

/**
 *	@brief	タウン表示状態の初期描画
 */
void PGMapSub_DrawTownMap(PGMAP_SYS_WORK* wk)
{
	int i;
	const TMAP_TOWN_PARAM *tp;

	GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_M,
		0,0,47,20,
		wk->pSMap->rawData,
		0,0,
		wk->pSMap->screenWidth/8,wk->pSMap->screenHeight/8);

	//マップオープン状態の制御
	switch(wk->f_open){
	case 0:
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_M,
			22,0,6,20,wk->pSMap->rawData,48,0,
			wk->pSMap->screenWidth/8,wk->pSMap->screenHeight/8);
		break;
	case 1:
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_M,
			29,0,3,20,wk->pSMap->rawData,54,0,
			wk->pSMap->screenWidth/8,wk->pSMap->screenHeight/8);
		break;
	}

	//タウンの表示状態制御
	for(i = 0;i < PGMAP_TOWN_MAX;i++){
		tp = &(TMapTownParam[i]);
		//サファリ連結部分は特殊処理
		if(tp->zoneid == ZONE_ID_T24){
			continue;
		}
		if(tp->gmap_idx == 0xFF){	//書換えナシのエリア
			continue;
		}
		if(wk->f_open < 2 && (PGFrame_GetLocalAreaPos(tp->px,tp->pz)==PGLOCAL_KANTO)){
			continue;
		}
		if(!SysFlag_ArriveGet( wk->sys->ev_save,tp->arrive)){
			GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_M,
				tp->px-tp->ox,tp->pz-tp->oy+PGMAP_MATOFS_Z,tp->sx,tp->sy,
				wk->pSMap->rawData,tp->dx,tp->dy,
				wk->pSMap->screenWidth/8,wk->pSMap->screenHeight/8);
		}
	}

	//サファリとT24の表示を制御
	if(wk->arrive_safari){
		if(!wk->arrive_t24){
			GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_M,
				SAFARI_PX,SAFARI_PY,SAFARI_SX,SAFARI_SY,
				wk->pSMap->rawData,SAFARI_SPX02,SAFARI_SPY02,
				wk->pSMap->screenWidth/8,wk->pSMap->screenHeight/8);
		}
	}else if(wk->arrive_t24){
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_M,
			SAFARI_PX,SAFARI_PY,SAFARI_SX,SAFARI_SY,
			wk->pSMap->rawData,SAFARI_SPX01,SAFARI_SPY01,
			wk->pSMap->screenWidth/8,wk->pSMap->screenHeight/8);
	}else{
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_M,
			SAFARI_PX,SAFARI_PY,SAFARI_SX,SAFARI_SY,
			wk->pSMap->rawData,SAFARI_SPX00,SAFARI_SPY00,
			wk->pSMap->screenWidth/8,wk->pSMap->screenHeight/8);
	}
	//シント遺跡の表示制御
	if(wk->arrive_shinto){
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_M,
			SHINTO_PX,SHINTO_PY,SHINTO_SX,SHINTO_SY,
			wk->pSMap->rawData,SHINTO_SPX00,SHINTO_SPY00,
			wk->pSMap->screenWidth/8,wk->pSMap->screenHeight/8);
	}
	//船の表示制御
	if(wk->arrive_ship){
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_M,
			SHIP_PX,SHIP_PY,SHIP_SX,SHIP_SY,
			wk->pSMap->rawData,SHIP_SPX00,SHIP_SPY00,
			wk->pSMap->screenWidth/8,wk->pSMap->screenHeight/8);
	}
}

/**
 *	@brief	ターゲットゾーンのハイライト表示
 */
void PGMapSub_DrawTargetZoneHilight(PGMAP_SYS_WORK* wk,u8 mode)
{
	int i;
	u16	x,z;
	const MAP_ZONE_PARAM* pz;

#ifdef PM_DEBUG
	if(wk->map_mode == MAP_MODE_JUMP && !wk->debug_f){
		return;
	}
#else
	if(wk->map_mode == MAP_MODE_JUMP){
		return;
	}
#endif
	if(mode == FALSE || wk->cZone.z_prm == NULL){
		GF_BGL_ScrClear(wk->sys->bgl,GF_BGL_FRAME2_M);
		GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME2_M);
		//BTS4359 前回ゾーンIDの保存
		wk->before_zone_id = 0;
		return;
	}

	//BTS4359 前回ゾーンIDをチェックし同じなら動作無し
	if( wk->cZone.z_prm->zone_id == wk->before_zone_id )
	{
		return;
	}
	wk->before_zone_id = wk->cZone.z_prm->zone_id;

	GF_BGL_ScrClear(wk->sys->bgl,GF_BGL_FRAME2_M);
	for(i = 0;i < wk->zTblMax;i++){
		if(wk->pMZoneTbl[i].zone_id != wk->cZone.z_prm->zone_id){
			continue;
		}
		pz = &(wk->pMZoneTbl[i]);
		if(pz->tsx*pz->tsy >= 9){
			x = pz->x-1;
			z = pz->z-1;
		}else{
			x = pz->x;
			z = pz->z;
		}
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME2_M,
			x,z,pz->tsx,pz->tsy,
			wk->pSMap->rawData,pz->tx,pz->ty,
			wk->pSMap->screenWidth/8,wk->pSMap->screenHeight/8);
	}
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME2_M);
}

/**
 *	@brief	アプリキーモードからシステムキーモードへの描画切替
 */
void PGMapSub_ToSysKeyChange(void* app_wk)
{
	PGMAP_SYS_WORK* wk = (PGMAP_SYS_WORK*)app_wk;

	//マップカーソル非表示
	CLACT_SetDrawFlag(wk->pActWMan->pAct[NACT_CURSOR].act,FALSE);

	//タッチパネルのステータスを解除
	wk->touch_st = 0;
}

/**
 *	@brief	マップのキーからタッチへの描画切替
 */
void PGMapSub_ToTouchChangeMap(void* app_wk)
{
	PGMAP_SYS_WORK* wk = (PGMAP_SYS_WORK*)app_wk;

//	if(wk->sys->key_mode == APP_KTST_KEY){
		//マップカーソル非表示
//		CLACT_SetDrawFlag(wk->pActWMan->pAct[NACT_CURSOR].act,FALSE);
//	}else{
		//システムカーソル非表示
		CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,PGKM_SYS_PARAM,FALSE);
//	}
	//マップカーソル表示
	PGMapSub_SetCursor2TargetPos(wk);
	CLACT_SetDrawFlag(wk->pActWMan->pAct[NACT_CURSOR].act,TRUE);

	//ターゲットゾーンをマーク
	PGMapSub_DrawTargetZoneHilight(wk,TRUE);

	//MainBG2(マップエフェクト面)を表示
	GF_BGL_VisibleSet(GF_BGL_FRAME2_M,VISIBLE_ON);
}

/**
 *	@brief	マップのタッチからキーへの描画切替
 */
void PGMapSub_ToKeyChangeMap(void* app_wk)
{
	PGMAP_SYS_WORK* wk = (PGMAP_SYS_WORK*)app_wk;

	//タッチから切り替えたら必ずアプリキーモード

	//マップカーソル表示
	PGMapSub_SetCursor2TargetPos(wk);
	CLACT_SetDrawFlag(wk->pActWMan->pAct[NACT_CURSOR].act,TRUE);

	//ターゲットゾーンのマークを非表示
//	PGMapSub_DrawTargetZoneHilight(wk,FALSE);

	//タッチパネルのステータスを解除
	wk->touch_st = 0;
}

/**
 *	@brief	マークのキーからタッチへの描画切替
 */
void PGMapSub_ToTouchChangeMark(void* app_wk)
{
	PGMAP_SYS_WORK* wk = (PGMAP_SYS_WORK*)app_wk;

	CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,CURMV_CURRENT,FALSE);
}

/**
 *	@brief	マークのタッチからキーへの描画切替
 */
void PGMapSub_ToKeyChangeMark(void* app_wk)
{
	PGMAP_SYS_WORK* wk = (PGMAP_SYS_WORK*)app_wk;

	CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,CURMV_CURRENT,TRUE);
}

/**
 *	@brief	マップ画面 ボタンパネルの描画ステート変更
 */
void PGMapSub_MapPanelStChange(PGMAP_SYS_WORK* wk,u8 mode,u8 st)
{
	if(mode == 0){
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME1_M,
			26,2,6,7,	wk->pSFrm->rawData,
			st*6,21,	wk->pSFrm->screenWidth/8,wk->pSFrm->screenHeight/8);
	}else{
		GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME1_M,
			26,11,6,9,	wk->pSFrm->rawData,
			st*6+18,21,	wk->pSFrm->screenWidth/8,wk->pSFrm->screenHeight/8);
	}
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME1_M);
}

///セレクトボックス　ヘッダデータ構造体
static const SELBOX_HEAD_PRM data_sbox_prm = {
	TRUE,SBOX_OFSTYPE_CENTER,	///<ループフラグ、左寄せorセンタリング

	0,	///<項目表示オフセットX座標(dot)

	GF_BGL_FRAME0_M,		///<フレームNo
	SBOX_WPAL,				///<BGパレットID
	0,0,					///<Oam BGPri,SoftwarePri
	SBOX_FCGX,SBOX_WCGX,	///<ウィンドウcgx,フレームcgx
	SBOX_FCGX_SIZ,		///<占有キャラクタ領域サイズ(char)
};

/**
 *	@brief	セレクトボックスの表示
 */
void PGMapSub_SkySelBoxSet(PGMAP_SYS_WORK* wk,u16 tx)
{
	int i;
	u8	key_mode;
	SELBOX_HEADER head;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	MI_CpuClear8(&head,sizeof(SELBOX_HEADER));

	head.prm = data_sbox_prm;
	head.list = (const BMPLIST_DATA*)wk->plist;
	head.bgl = wk->sys->bgl;

	head.count = SBOX_COUNT;

	IWASAWA_PRINT(" tx = %d\n",tx);
	if(tx < 8 || tx > 15){
		wk->list_wk = SelectBoxSet(wk->sbox,&(head),wk->sys->key_mode,11,4,0,0);
	}else{
		wk->list_wk = SelectBoxSet(wk->sbox,&(head),wk->sys->key_mode,3,4,0,0);
	}
}

/**
 *	@brief	操作説明メッセージ描画
 */
void PGMapSub_PrintExpMsg(PGMAP_SYS_WORK* wk,int zone)
{
	GF_BGL_BmpWinDataFill(&(wk->win[WIN_EXP01]),0);

	if(zone  < 0){
		GF_STR_PrintColor( &(wk->win[WIN_EXP01]),FONT_SYSTEM,
							wk->msgDat.exp[0],
							8,0,MSG_ALLPUT,EXP_COL01,NULL );
	}else{
		sub_GetPlaceNameFromZoneID(zone,wk->heapID,wk->msgDat.place);
		WORDSET_RegisterWord(wk->msgDat.wset,0,wk->msgDat.place,PM_MALE,FALSE, PM_LANG);
		WORDSET_ExpandStr(wk->msgDat.wset,wk->msgDat.tmp,wk->msgDat.exp[1]);

		GF_STR_PrintColor( &(wk->win[WIN_EXP01]),FONT_SYSTEM,
							wk->msgDat.tmp,
							8,0,MSG_ALLPUT,EXP_COL01,NULL );
	}
	//スクリーン転送
//	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME0_M);
}

static void sub_GetPlaceNameFromZoneID(u16 zone_id,int heapID,STRBUF* buf)
{
#if 0
	//フロンティアと自然公園は、空を飛ぶの対象ゾーン指定の関連で
	//地名表示に使いたいゾーンと、マップデータテーブルに登録されたゾーンが異なるので
	//特別扱いする
	switch(zone_id){
	case ZONE_ID_D32R0102:	//フロンティア
		zone_id = ZONE_ID_D32;
		break;
	case ZONE_ID_D49:	//スロン会場
		zone_id = ZONE_ID_D22R0101;
		break;
	}
#endif
	PNC_GetPlaceNameFromZoneID(zone_id,heapID,buf);
}